home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / sync / RCS / sync.h,v < prev    next >
Text File  |  1988-08-25  |  6KB  |  211 lines
  1. head     1.2;
  2. access   ;
  3. symbols  ;
  4. locks    ; strict;
  5. comment  @ * @;
  6.  
  7.  
  8. 1.2
  9. date     88.08.25.16.45.39;  author douglis;  state Exp;
  10. branches ;
  11. next     1.1;
  12.  
  13. 1.1
  14. date     88.06.19.14.34.05;  author ouster;  state Exp;
  15. branches ;
  16. next     ;
  17.  
  18.  
  19. desc
  20. @@
  21.  
  22.  
  23. 1.2
  24. log
  25. @added (void) cast for call of Sync_SlowBroadcast.
  26. @
  27. text
  28. @/*
  29.  * sync.h --
  30.  *
  31.  *     Typedefs and macros to support the use of monitors.
  32.  *      Clients use the macros to acquire and release monitor locks, and
  33.  *      to wait on and notify monitored condition variables.  Only Broadcast
  34.  *      semantics are supported for lock release; that is, all processes
  35.  *      waiting on a lock are made runnable when the locked is released.
  36.  *
  37.  *      These macros do a fast check on the state of the lock or condition
  38.  *      variable to reduce overhead.  In the best case the lock and unlock
  39.  *      routines just set or clear flags.  In the worst case these routines
  40.  *      have to call slower routines that must acquire a master lock.
  41.  *
  42.  * Copyright 1986, 1988 Regents of the University of California
  43.  * Permission to use, copy, modify, and distribute this
  44.  * software and its documentation for any purpose and without
  45.  * fee is hereby granted, provided that the above copyright
  46.  * notice appear in all copies.  The University of California
  47.  * makes no representations about the suitability of this
  48.  * software for any purpose.  It is provided "as is" without
  49.  * express or implied warranty.
  50.  *
  51.  *
  52.  * $Header: sync.h,v 1.1 88/06/19 14:34:05 ouster Exp $ SPRITE (Berkeley)
  53.  */
  54.  
  55. #ifndef _SYNCUSER
  56. #define _SYNCUSER
  57.  
  58. #ifndef _SPRITE
  59. #include "sprite.h"
  60. #endif
  61.  
  62. /*
  63.  * The state of a lock consists of two bits of information, a lock bit
  64.  * and a waiting bit.  The lock bit indicates that someone has the
  65.  * lock, and no other process can acquire the lock until this bit is
  66.  * cleared.  The waiting bit indicates that someone wants the lock.
  67.  *
  68.  * Note: the inUse field is a whole word so it can be
  69.  *       an argument to the test-and-set instruction.
  70.  */
  71.  
  72. typedef struct Sync_Lock {
  73.     Boolean inUse;        /* 1 while the lock is busy */
  74.     Boolean waiting;        /* 1 if someone wants the lock */
  75. } Sync_Lock;
  76.  
  77. /*
  78.  * Condition variables represent events that are associated with
  79.  * locks.  The operations on a condition variable are Sync_Wait and
  80.  * Sync_Broadcast. The lock must be acquired before a call to
  81.  * Sync_Wait is made.  The lock is released while a process waits on a
  82.  * condition, and is then re-acquired when the condition is notified
  83.  * via Sync_Broadcast.
  84.  */
  85.  
  86. typedef struct Sync_Condition {
  87.     Boolean waiting;        /* 1 if someone is waiting on the condition */
  88. } Sync_Condition;
  89.  
  90.  
  91. /*
  92.  * ----------------------------------------------------------------------------
  93.  *
  94.  * Monitor Locks --
  95.  *
  96.  *    The following set of macros are used to emulate monitored
  97.  *    procedures of Mesa.  The Sprite style document has a complete
  98.  *    description of the conventions required to emulate a set
  99.  *    of monitored procedures; a summary is presented here.
  100.  *
  101.  *      The LOCK_MONITOR and UNLOCK_MONITOR macros depend on a constant
  102.  *      LOCKPTR.  LOCKPTR should be defined as the address of the lock
  103.  *      variable used to lock the monitor.  Something like the following
  104.  *      two lines of code should appear at the beginning of a file of
  105.  *      monitored procedures.
  106.  *
  107.  *    Sync_Lock modMonitorLock;
  108.  *    #define LOCKPTR (&modMonitorLock)
  109.  *
  110.  *    The pseudo-keywords INTERNAL and ENTRY denote internal and entry
  111.  *    procedures of a monitor.  INTERNAL procedures can only be called
  112.  *    when the monitor lock is held.  ENTRY procedures are procedures
  113.  *    that acquire the lock.  There may also be External procedures.
  114.  *    They are the default and there is no special keyword.  An External
  115.  *    procedure doesn't explicitly acquire the monitor lock, but may
  116.  *    call an ENTRY procedure.
  117.  *
  118.  * ----------------------------------------------------------------------------
  119.  */
  120.  
  121. #define LOCK_MONITOR               Sync_GetLock(LOCKPTR)
  122. #define UNLOCK_MONITOR             Sync_Unlock(LOCKPTR)
  123.  
  124. #define ENTRY
  125. #define INTERNAL
  126.  
  127.  
  128. /*
  129.  * ----------------------------------------------------------------------------
  130.  *
  131.  * Sync_Wait --
  132.  *
  133.  * Wait on a condition variable.  This can only be called while a lock
  134.  * is aquired because it is only safe to check global state while in a
  135.  * monitor.  This releases the monitor lock and makes the process sleep
  136.  * on the condition. The monitor lock is reacquired after the process 
  137.  * has been woken up.
  138.  *
  139.  * The address of the condition variable is used as the generic 'event'
  140.  * that the process blocks on.  The value of the condition variable is
  141.  * used to indicate if there is a process waiting on the condition.
  142.  *
  143.  * Results:
  144.  *    None.
  145.  *
  146.  * Side effects:
  147.  *    Put the process to sleep and release the monitor lock.
  148.  *
  149.  * ----------------------------------------------------------------------------
  150.  */
  151.  
  152. #define Sync_Wait(conditionPtr, wakeIfSignal) \
  153.     Sync_SlowWait(conditionPtr, LOCKPTR, wakeIfSignal)
  154.  
  155.  
  156. /*
  157.  * ----------------------------------------------------------------------------
  158.  *
  159.  * Sync_Broadcast --
  160.  *
  161.  *      Notify other processes that a condition has been met.  If the
  162.  *      condition variable indicates that there are processes waiting
  163.  *      on the condition, then Sync_SlowBroadcast is used to wakeup
  164.  *      waiting processes.
  165.  *
  166.  * Monitor Lock:
  167.  *    This routine needs to be called with the monitor lock held.
  168.  *    This ensures synchronous access to the conditionPtr->waiting flag.
  169.  *
  170.  * Results:
  171.  *    None.
  172.  *
  173.  * Side effects:
  174.  *    Make the processes waiting on the condition variable runnable.
  175.  *
  176.  * ----------------------------------------------------------------------------
  177.  */
  178.  
  179. #define Sync_Broadcast(conditionPtr) \
  180.     if (((Sync_Condition *)conditionPtr)->waiting == TRUE)  { \
  181.     (void) Sync_SlowBroadcast((unsigned int) conditionPtr, \
  182.       &((Sync_Condition *)conditionPtr)->waiting); \
  183.     }
  184.  
  185. /*
  186.  * Exported procedures of the sync module for monitors.
  187.  */
  188.  
  189. extern ReturnStatus    Sync_GetLock();
  190. extern ReturnStatus    Sync_Unlock();
  191. extern ReturnStatus    Sync_SlowLock();
  192. extern ReturnStatus    Sync_SlowWait();
  193. extern ReturnStatus    Sync_SlowBroadcast();
  194.  
  195. #endif _SYNCUSER
  196. @
  197.  
  198.  
  199. 1.1
  200. log
  201. @Initial revision
  202. @
  203. text
  204. @d25 1
  205. a25 1
  206.  * $Header: syncMonitor.h,v 2.0 87/08/11 09:32:49 brent Exp $ SPRITE (Berkeley)
  207. d154 1
  208. a154 1
  209.     Sync_SlowBroadcast((unsigned int) conditionPtr, \
  210. @
  211.